Seems like the code is too long so I made a pdf: https://drive.google.com/file/d/0B9pKdSOwgbtydjN1aU03TGQtSUk/view?usp=sharing

function Cell(i,j){
  this.r = j;
  this.c = i;
  this.x = this.c*res;
  this.y = this.r*res;
  this.state = floor(random(0,1)+.5);
  this.next;
  this.getNeighborhood = () => {
    let temp = [];
    for (let k = -1; k <=1; k++){
      for (let l = -1; l <= 1; l++){
        if (inRange(k,0,cols) && inRange(l,0,rows)){
          temp.push(grid[this.c+k][this.r+l]);
        }
      }
    }
    return temp;
  }
  this.show = () => {
    stroke(0);
    fill(this.state*255);
    rect(this.x,this.y,res,res);
  }
}

function inRange(val,min,max){
  return (val>=min&&val<max)
}

Those two functions are in a separate file from the main sketch.

Here's the main sketch:

var res = 10;
var cols;
var rows;
var grid;

function setup(){
  createCanvas(600,600);
  cols = floor(width/res);
  rows = floor(height/res);
  grid = new Array(cols);
  for (let i = 0; i < grid.length; i++){
    grid[i] = new Array(rows);
    for (let j = 0; j < grid[i].length; j++){
      grid[i][j] = new Cell(i,j);
    }
  }
}

function draw(){
  background(255);
  for (let i = 0; i < grid.length; i++){
    for (let j = 0; j < grid[i].length; j++){
      let cell = grid[i][j];
      cell.show();
      cell.next = computeState(cell);
      cell.state = cell.next;
      cell.show();
    }
  }
}

I recently found processing and thought the Game of Life would be an easy first project. But when I tried going from neighbourCount only, to saving neighbours in order - in an Array - I stopped getting neighbourCounts bigger than one.

I know it is not needed to store the specific configuration of neighbours to make the Game of Life work, but I want to expand on the idea once I get this working. Why am I not getting the right neighbourCount? I know it's a lot, but I put in as many comments as possible to make it easier on the eyes.

int interval = 1000;                         // time between iterations
int lastRecordedTime = 0;                    // timer

int cellSize = 5;                            // size of one Cell
int counterLocal;                            // variable for storing neighbourCount
int [] neighbourhood = {0,0,0,0,0,0,0,0};    // Array for storing neighbourhood configuration
int [][] cells;                              // 2D Cells Array
int [][] cellsBuffer;                        // 2D Buffer Array to work on while leaving cells[][] unharmed

float prob = 30;                             // probability of Cell being alive at setup

color alive = color(0, 0, 0);                // Alive color = black
color dead = color(255, 255, 255);           // Dead color = white




void setup() {
  size (200, 200);
  cells = new int [width/cellSize][height/cellSize];
  cellsBuffer = new int [width/cellSize][height/cellSize];
  stroke(48);
  noSmooth();

  for ( int x = 0; x < width/cellSize; x++) {                // Randomize cells[][]
    for ( int y = 0; y < height/cellSize; y++) {
      float state = random(100);
      if (state > prob) {
        state = 0;
      } else {
        state = 1;
      }
      cells[x][y] = int(state);
    }
  }
  background(0);
} // end of setup()




void draw() {                                                // Loop through every cell in cells[][] and draw them according to their state
  for ( int x = 0; x < width/cellSize; x++) {
    for ( int y = 0; y < height/cellSize; y++) {
      if (cells[x][y] == 1) {
        fill(alive);
      } else {
        fill (dead);
      }
      rect (x*cellSize, y*cellSize, cellSize, cellSize);
    }
  }
  if (millis() - lastRecordedTime > interval) {
    iteration();
    lastRecordedTime = millis();
  }
} // end of draw()





void iteration() {    
  for (int x = 0; x < width/cellSize; x++) {                                       // copy cells Array to cellsBuffer
    for (int y = 0; y < height/cellSize; y++) {
      cellsBuffer[x][y] = cells[x][y];
    }
  } 



  for (int x = 0; x < width/cellSize; x++) {                                       // go through every cell
    for (int y = 0; y < height/cellSize; y++) {

      String neighbourCode = "0,0,0,0,0,0,0,0";                                    // string used to encode neighbour positions    

      for (int xx=x-1; xx<=x+1; xx++) {                                            // go through all neighbours of current Cell
        for (int yy=y-1; yy<=y+1; yy++) {  

          if (((xx>=0)&&(xx<width/cellSize))&&((yy>=0)&&(yy<height/cellSize))) {   // Make sure you are not out of bounds
            //if (!((xx==x)&&(yy==y))) {                                           // Make sure to to check against self (not needed)

              int[] codeArray = int(split(neighbourCode, ","));                    // Split string into Array

              if ((x - xx == 1) && (y - yy == 1)) {           //top left           //1. Check which neighbour you are (if, else if, else if...)
                if (cellsBuffer[xx][yy] == 1){
                codeArray[0] = 1;                                                  //2. if alive, set codeArray at corresponding index to 1
                }
              }

              else if ((x - xx == 0) && (y - yy == 1)) {      //top mid
                if (cellsBuffer[xx][yy] == 1){
                codeArray[1] = 1;
                }
              }

              else if ((x - xx == -1) && (y - yy == 1)) {     //top right
                if (cellsBuffer[xx][yy] == 1){
                codeArray[2] = 1;
                }
              }

              else if ((x - xx == 1) && (y - yy == 0)) {       //mid left
                if (cellsBuffer[xx][yy] == 1){
                codeArray[3] = 1;
                }
              }

              else if ((x - xx == -1) && (y - yy == 0)) {      //mid right
                if (cellsBuffer[xx][yy] == 1){
                codeArray[4] = 1;
                }
              }

              else if ((x - xx == 1) && (y - yy == -1)) {      //bot left
                if (cellsBuffer[xx][yy] == 1){
                codeArray[5] = 1;
                }
              }

              else if ((x - xx == 0) && (y - yy == -1)) {       //bot mid
                if (cellsBuffer[xx][yy] == 1){
                codeArray[6] = 1;
                }
              }

              else if ((x - xx == -1) && (y - yy == -1)) {      //bot right
                if (cellsBuffer[xx][yy] == 1){
                codeArray[7] = 1;
                }
              }                                                 // finished making codeArray


              for (int n = 0; n < codeArray.length; n++) {      // copy codeArray to public Array
                neighbourhood[n] = codeArray[n];
              }



              int neighbourCount = 0;
              for (int neighbourIndex = 0; neighbourIndex < codeArray.length; neighbourIndex++) {      // Converting neighbourCode to neighbourCount
                if (codeArray[neighbourIndex] == 1) {
                  neighbourCount = neighbourCount + 1;
                }
               }                                                // end of Conversion
               counterLocal = neighbourCount;                   // copy neighbourCount to public int

            //} // end of self check (not needed)
          } // end of out of Bounds check
        } // end of for (yy++) loop
      } // end of for (xx++) loop





        if (cellsBuffer[x][y] == 1) {                                              // applying ruleset for the game of life and writing to cells Array
          if (counterLocal < 2 || counterLocal > 3) {
            cells [x][y] = 0;
          }
        } else {
          if (counterLocal == 3) {
            cells[x][y] = 1;
          }
        }



    } // end of for (y++) loop
  } // end of for (x++) loop
}  //end of iteration ()

If you're still reading this, you are my hero.

My question is about how to stock and access the rules.

We have variables number S of states and N of neighbors (it doesn't change after automaton initialization), and I want to access a particular rule by giving the number of neighbors in each state and the cell's actual state.

So at first I thought to an array of size S (for the actual state) of emulated S-dimensional arrays of size N (N^S arrays).

For example, the rules of the Game of Life would look like that :

{{
    0,0,0,0,0,0,0,0, 0,
    0,0,0,0,0,0,0, 0,0,
    0,0,0,0,0,0, 0,0,0,
    0,0,0,0,0, 1,0,0,0,
    0,0,0,0, 0,0,0,0,0,
    0,0,0, 0,0,0,0,0,0,
    0,0, 0,0,0,0,0,0,0,
    0, 0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,0
  }, {
    0,0,0,0,0,0,0,0, 0,
    0,0,0,0,0,0,0, 0,0,
    0,0,0,0,0,0, 1,0,0,
    0,0,0,0,0, 1,0,0,0,
    0,0,0,0, 0,0,0,0,0,
    0,0,0, 0,0,0,0,0,0,
    0,0, 0,0,0,0,0,0,0,
    0, 0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,0
  }}

As you see it's really not optimal.

Because numbers of neighbors in each state add up to N, there are only (N + S - 1)! / (N! (S - 1)! elements used on the N^S in each sub array.

I run out of ideas, so I hope you might help find a better way to store my rules.

I programmed this is eclipse, so I cannot really port it to open processing or anything(well I could, but I don't know javascript). Anyways, the github link has a zip of the source with some screenshots I was playing around with and it has a zip with a compiled jar of my code(Note: the settings are in, well, the settings folder, and should be mostly self explanatory, but if you have any questions, just ask!). https://github.com/awesommee333/LYFE

And here is a screenshot of something I made with this program:

(My Code is shit but it works)

THE CODE IS BUGGY ON THE PROCESSINg WEBSITE SO I POSTED IT ON PASTEBIN http://pastebin.com/zh5uupi3 http://pastebin.com/zh5uupi3 http://pastebin.com/zh5uupi3

// GameSize = 10x10
  int gameSize = 100;
  Cell[][] c = new Cell[gameSize][gameSize];
  int fr = 10;
  int frames = 0;

  boolean isDraving = true;

  void setup() {
    size(400, 400);
    frameRate(30);
    noStroke();

    // random cells are alive
    for (int x = 0; x < gameSize; x++) {
      for (int y = 0; y < gameSize; y++) {
        c[x][y] = new Cell();
        if (random(1)< 0.05) {
          c[x][y].alive = true;
        }
      }
    }
  }

  void draw() {
    frames++;
    if (!isDraving) {
      if (frames % fr == 0) {
        for (int x = 0; x < gameSize; x++) {
          for (int y = 0; y < gameSize; y++) {

            // CALCULATE LIVING CELLES
            int lc = 0;
            try { // left upper
              if (c[x-1][y-1].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { //  upper
              if (c[x][y-1].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { // right upper
              if (c[x+1][y-1].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { // left
              if (c[x-1][y].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { // right
              if (c[x+1][y].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { // left down
              if (c[x-1][y+1].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { // down
              if (c[x][y-1].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            try { // right down
              if (c[x+1][y+1].alive == true) lc++;
            } 
            catch(Exception e) {
            }

            if (lc > 0) println(lc);
            c[x][y].calculate(lc);

            // DRAW CELLES
            if (c[x][y].alive) {
              fill(255);
            } else {
              fill(0);
            }
            rect(width/gameSize*x, height/gameSize*y, width/gameSize, height/gameSize);
          }
          if (keyPressed) isDraving = true;
        }
      }
    } else {

      if (mousePressed) {
        int mx = floor( mouseX /(width/gameSize));
        int my = floor( mouseY /(width/gameSize));

        c[mx][my].alive = true;
      }

      if (keyPressed) isDraving = false;

      for (int x = 0; x < gameSize; x++) {
        for (int y = 0; y < gameSize; y++) {
          // DRAW CELLES
          if (c[x][y].alive) {
            fill(255);
          } else {
            fill(0);
          }
          rect(width/gameSize*x, height/gameSize*y, width/gameSize, height/gameSize);
        }
      }
    }
  }


  class Cell {
    boolean alive;

    void calculate(int lN) {
      if (lN == 3 || lN == 2) {
        // NOTHING ;D
        alive = true;
        //println("ALIVE");
      }
      if (lN < 2) {
        alive = false;
      }
      if (lN > 3) {
        alive = false;
      }
    }
  }

The logic I implemented to check how many "alive neighbors" a cell consistently gets the number of alive neighbors incorrect... Below is the code, with some sample output.

 final int SIZE = 5;
final int SCREEN_WIDTH = 500;
final int SCREEN_HEIGHT = 500;

final color ON = color(255, 255, 255);
final color OFF = color(0);

final int SQUARE_LENGTH = SCREEN_WIDTH/SIZE;

boolean [][] GOL_Grid = new boolean[SIZE][SIZE];

void setup()
{
  size(500, 500);
  background(200);
  println("BEFORE ASSIGNMENT");
  printGrid(GOL_Grid);

  //Attempting to make the "Blinker" oscillator (found on the wikipedia page for Conway's Game Of Life)
  GOL_Grid[1][2] = true;
  GOL_Grid[2][2] = true;
  GOL_Grid[3][2] = true;
    println("AFTER ASSIGNMENT");
  printGrid(GOL_Grid);

  GOL_Grid = updateGrid(GOL_Grid);
  println("AFTER UPDATING");
  printGrid(GOL_Grid);
}

void drawGrid(final boolean[][] grid)
{
  println("------------------------");
  for (int i = 0; i < grid.length; i++)
  {
    int curr_Y = i*SQUARE_LENGTH;
    for (int j = 0; j < grid[i].length; j++)
    {
      if (grid[i][j])
        print( "X\t");
      else
        print("-\t");
      int curr_X = j*SQUARE_LENGTH;
      stroke(255);
      if (grid[i][j])
        fill(ON); 
      else
        fill(OFF);

      rect(curr_X, curr_Y, SQUARE_LENGTH, SQUARE_LENGTH);
    }
    println();
  }
  println("------------------------");
}

/************
 (1) Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
 (2) Any live cell with two or three live neighbours lives on to the next generation.
 (3) Any live cell with more than three live neighbours dies, as if by overpopulation.
 (4) Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

 *************/
boolean updateCell(final boolean[][] grid, int row, int col)
{
  int neighborCount = 0;
  boolean isAlive = grid[row][col];

  for (int newRow = row-1; newRow <= row+1; newRow++)
  {
    if (newRow < 0 || newRow >= SIZE) continue; //Bounds check

    for (int newCol = col-1; newCol <= col+1; newCol++)
    {
      if (newCol < 0 || newCol >= SIZE) continue; //Bounds check

      if (row == newRow && col == newCol) continue;
      if (grid[newRow][newCol] == true) //Checks if each neighbor is "alive"
        neighborCount++; //The current cell's alive/death state is based on how many of its neighbors are alive
    }
  }
  print(neighborCount + "\t"); //Prints how many neighbors there are, for debugging purposes
  boolean update = grid[row][col];

  if (neighborCount < 2 || neighborCount > 3)
    update = false; //Cell is dead;
  if (!grid[row][col] && neighborCount == 3) 
    update = true;

  return update;
}

boolean[][] updateGrid(final boolean[][] grid)
{
println("NOW UPDATING GRID (Now showing how many alive neigbors a particular cell has): "); 
  boolean[][] grid_COPY = grid;
  for (int row = 0; row < SIZE; row++) //Iterate through once per cell in the original grid
  {
    for (int col = 0; col < SIZE; col++)
    {
      grid_COPY[row][col] = updateCell(grid, row, col);
    }
    println();
  }
  return grid_COPY;
}

void printGrid(boolean[][] grid)
{
  println("------------------------");
  for (int i = 0; i < grid.length; i++)
  {
    int curr_Y = i*SQUARE_LENGTH;
    for (int j = 0; j < grid[i].length; j++)
    {
      if (grid[i][j])
        print( "X\t");
      else
        print("-\t");
    }
    println();
  }
  println("------------------------");
}

I should mention that while debugging, I think the error lies in either the updateGrid or the updateCell functions

OUTPUT:

BEFORE ASSIGNMENT
------------------------
-   -   -   -   -   
-   -   -   -   -   
-   -   -   -   -   
-   -   -   -   -   
-   -   -   -   -   
------------------------
AFTER ASSIGNMENT
------------------------
-   -   -   -   -   
-   -   X   -   -   
-   -   X   -   -   
-   -   X   -   -   
-   -   -   -   -   
------------------------
NOW UPDATING GRID (Now showing how many alive neighbors a particular cell has): 
0   1   1   1   0   
0   2   1   1   0   
0   2   1   1   0   
0   1   0   0   0   
0   0   0   0   0   
AFTER UPDATING
------------------------
-   -   -   -   -   
-   -   -   -   -   
-   -   -   -   -   
-   -   -   -   -   
-   -   -   -   -   
------------------------

import peasy.*;
import saito.objloader.*;
import spout.*;
import SimpleOpenNI.*;

//PrintWriter output;
OBJModel model ;
OBJModel Smodel ;
OBJModel tmpmodel ;

Spout spout;

SimpleOpenNI kinect;

PeasyCam cam;

float z=0;

float r;
float k;
int VertCount;
PVector[] Verts;
PVector[] locas;
PVector[] Bez;
PVector[] Bez2;
PVector Mouse;
PVector Mouse2;
PVector rightHand;
PVector convertedRightHand;
PVector leftHand;
PVector convertedLeftHand;
PVector rightShoulder;
PVector convertedRightShoulder;
PVector leftShoulder;
PVector convertedleftShoulder;
float rightHandZ;
float ConrightHandZ;
float leftHandZ;
float ConleftHandZ;

boolean Kin;

boolean Text1;
boolean Text2;

PImage img;
PImage img2;


int Tmeter=0;

int VECS = 800;


void setup()
{
  size(1920, 1440, P3D);

  //hypotenuse 2450

  frameRate(30);
  noStroke();

  kinect = new SimpleOpenNI(this);
  kinect.enableDepth();
  kinect.enableUser();

  //800*800-->200,1920*1440-->300
  model = new OBJModel(this, "Model2.obj", "absolute", TRIANGLES);
  model.enableDebug();
  model.scale(300);
  model.translateToCenter();


  Smodel = new OBJModel(this, "Model2.obj", "absolute", TRIANGLES);
  Smodel.enableDebug();
  Smodel.scale(300);
  Smodel.translateToCenter();


  tmpmodel = new OBJModel(this, "Model2.obj", "absolute", TRIANGLES);
  tmpmodel.enableDebug();
  tmpmodel.scale(300);
  tmpmodel.translateToCenter();

  //output = createWriter("positions.txt"); 

  cam = new PeasyCam(this, width/2, height/2, 0, 2610);
  //800*800 --> cam 1600,1920*1440--> cam 2610
  spout = new Spout(this);
  spout.createSender("Self kinect");

  img = loadImage("Text1.png");
  img2 = loadImage("Text2.png");
}



void draw()
{
  background(0);
  pointLight(255, 255, 255, 
  width/2, height/2, width*2);

  kinect.update();
  IntVector userList = new IntVector();
  kinect.getUsers(userList);

  int VertCount = model.getVertexCount ();
  Verts = new PVector[VertCount];
  locas = new PVector[VertCount];
  Bez = new PVector[VertCount];
  Bez2 = new PVector[VertCount];
  r =300;
  k = k + 0.01;



  PVector psVerts[] = new PVector[VECS];
  PVector psVerts2[]= new PVector[VECS];


  cam.setMouseControlled(false);

  if (userList.size() <= 0) {
    Text1 = false;
    Text2= false;
    Tmeter=0;
  }

  if (userList.size() > 0) {


    int userId = userList.get(0);
    Text1 = true;

    if ( kinect.isTrackingSkeleton(userId)) {



      Kin= true;


      Text1 = false;


      Text2=true;



      pushMatrix();
      translate(0, 0, 1255);
      //the hypotenuse

      image(img2, 0, 0);

      popMatrix();
      Tmeter+=1;


      if (Tmeter>=10 ) {
        Text2=false;
        //print("ok");
        //print(Text2);
      }

      print(Tmeter);

      rightHand = new PVector();
      kinect.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_LEFT_HAND, rightHand);

      convertedRightHand = new PVector();
      kinect.convertRealWorldToProjective(rightHand, convertedRightHand);

      leftHand = new PVector();
      kinect.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_RIGHT_HAND, leftHand);

      convertedLeftHand = new PVector();
      kinect.convertRealWorldToProjective(leftHand, convertedLeftHand);


      rightShoulder = new PVector();
      kinect.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_LEFT_SHOULDER, rightShoulder);

      convertedRightShoulder = new PVector();
      kinect.convertRealWorldToProjective(rightShoulder, convertedRightShoulder);


      leftShoulder = new PVector();
      kinect.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_RIGHT_SHOULDER, leftShoulder);

      convertedleftShoulder = new PVector();
      kinect.convertRealWorldToProjective(leftShoulder, convertedleftShoulder);






      rightHandZ =  map(rightHand.z, 5500, 7500, 1100, 1500);
      ConrightHandZ = map(rightHandZ, 1100, 1500, 0, 1440);

      leftHandZ =map(leftHand.z, 5500, 7500, 1100, 1500);
      ConleftHandZ = map(leftHandZ, 1100, 1500, 0, 1440);

      Mouse = new PVector(rightHand.x, -rightHand.y, z);
      Mouse2 = new PVector(leftHand.x, -leftHand.y, z);


      pushMatrix();
      translate(width/2, height/2, 0);



      pushMatrix();
      //-----------------HERE
      translate(Mouse2.x, Mouse2.y, Mouse2.z);
      //-------------AND HERE
      noFill();
      stroke(255);
      strokeWeight(3);
      box(r, r, 2450);
      popMatrix();



      pushMatrix();
      //-----------------HERE
      translate(Mouse.x, Mouse.y, Mouse.z);
      //-------------AND HERE
      noFill();
      stroke(255);
      strokeWeight(3);
      box(r, r, 2450);
      popMatrix();


      popMatrix();
    }
  }

  pushMatrix();




  translate(width/2, height/2, 0);



  for (int i = 0; i < VertCount; i++) {
    //PVector orgv = model.getVertex(i);

    locas[i]= model.getVertex(i);
    Verts[i]= Smodel.getVertex(i);


    //PVector tmpv = new PVector();





    //+4 for 1920*1440
    float randX = noise(randomGaussian())+4;
    float randY = noise(randomGaussian())+4;
    float randZ = noise(randomGaussian())+4;

    PVector Ran = new PVector(randX, randY, randZ);




    Verts[i].x+=Ran.x;
    Verts[i].y+=Ran.y;
    Verts[i].z+=Ran.z;

    if (Verts[i].x > width/2 ) {
      Verts[i].x=-width/2;
    } else if (Verts[i].x < -width/2) {
      Verts[i].x=width/2;
    }
    if (Verts[i].y > height/2 ) {
      Verts[i].y=-height/2;
    } else if (Verts[i].y < -height/2) {
      Verts[i].y=height/2;
    }

    if (Verts[i].z < -width/2 ) {  
      Verts[i].z=800/2;
    } else if ( Verts[i].z > width/2) {
      Verts[i].z=-width/2;
    }


    pushMatrix();
    translate(width/2, height/2, 0);
    rotateY(k);
    tmpmodel.setVertex(i, Verts[i].x, Verts[i].y, Verts[i].z);
    popMatrix();




    if (Kin==true) {
      if ((Verts[i].y > Mouse.y  - r/2 && Verts[i].y < Mouse.y  + r/2 && Verts[i].x > Mouse.x  - r/2 && Verts[i].x < Mouse.x  + r/2 && Verts[i].z > Mouse.z  - 1225 && Verts[i].z <  Mouse.z  + 1225)||(Verts[i].y > Mouse2.y  - r/2 && Verts[i].y < Mouse2.y  + r/2 && Verts[i].x > Mouse2.x  - r/2 && Verts[i].x < Mouse2.x  + r/2 && Verts[i].z > Mouse2.z  - 1225 && Verts[i].z <  Mouse2.z  + 1225)) {




        pushMatrix();
        rotateY(k);


        tmpmodel.setVertex(i, locas[i].x, locas[i].y, locas[i].z);
        popMatrix();
      }
    }
  }




  rotateY(k);
  noStroke();
  tmpmodel.draw();








  popMatrix();
  if (Text1==true) {

    pushMatrix();
    translate(0, 0, 1255);
    //the hypotenuse

    image(img, 0, 0);

    popMatrix();
  }





  spout.sendTexture();
  //println(Tmeter);
}




void onNewUser(SimpleOpenNI kinect, int userID) {
  kinect.startTrackingSkeleton(userID);
}


void onEndCalibration(int userId, boolean successful) {
  if (successful) {
    println(" User calibrated !!!");
    kinect.startTrackingSkeleton(userId);
  } else {
    println("  Failed to calibrate user !!!");
    kinect.startTrackingSkeleton(userId);
  }
}

// Birth and death cycle 
for (int x = 0; x < sx; x=x+1) { 
  for (int y = 0; y < sy; y=y+1) { 
    int count = neighbors(x, y); 
    if (count == 3 && world[x][y][0] == 0) 
    { 
      world[x][y][1] = 1; 
    } 
    if ((count < 2 || count > 3) && world[x][y][0] == 1) 
    { 
      world[x][y][1] = -1; 
    } 
  } 
} 

// Count the number of adjacent cells 'on' 
int neighbors(int x, int y) 
{ 
  return world[(x + 1) % sx][y][0] + 
  world[x][(y + 1) % sy][0] + 
  world[(x + sx - 1) % sx][y][0] + 
  world[x][(y + sy - 1) % sy][0] + 
  world[(x + 1) % sx][(y + 1) % sy][0] + 
  world[(x + sx - 1) % sx][(y + 1) % sy][0] + 
  world[(x + sx - 1) % sx][(y + sy - 1) % sy][0] + 
  world[(x + 1) % sx][(y + sy - 1) % sy][0]; 
}

I dont know principaly the "count the number of adjacent cells 'on'. I dont know what that lots of world do, i already tried to comment the parts, i know that it makes the "game" finish early, but i dont know exactly what they do. Could you guys help me? My teacher wants me to comment all the code, but i cant comment that part because i dont understand.